nightfury7 / universalbasics.js

/** global: Buffer */

/*! ARRAY UTILS */

var arrayFuncs = {

	merge: function(){

		var arr = this;

		var val1 = arr[0];

		// if array of strings

		if (val1.isString()){

			return val1.join("");

		}

		// if array of arrays

		if (val1.isArray()){

			var merged = [];

			for (var a = 0, al = arr.length; a<al; a++){

				merged.addArray(arr[a]);

			}

			return merged;

		}

		// if array of Buffers

		//removeIf(nodejs)

		if (val1 instanceof Buffer){

			// calc the total length of all buffers

			var buffers = arr;

			var len = 0;

			for(var b = 0, bl = buffers.length; b < bl; b++) {

				len += buffers[b].length;

			}

			// create a new buffer of that length

			var mega = new Buffer(len);

			// write all buffers into the mega buffer

			var cur = 0;

				buffers[b].copy(mega, cur, 0);

				cur += buffers[b].length;

			}

			return mega;

		}

		//endRemoveIf(nodejs)

		return null;

	},

	indexOf: function(value){

		var list = this;

		if (list.length === 0) {

			return -1;

		}

		for (var a = 0, al = list.length;a<al;a++){

			if (list[a] == value){

				return a;

			}

		}

		return -1;

	},

		var list = this;

		if (list.length === 0) {

			return -1;

		}

		for (var a = list.length-1;a>=0;a--){

			if (list[a] == value){

				return a;

			}

		}

		return -1;

	},

		var list = this;

		var total = 0;

		for (var a = 0, al = list.length;a<al;a++){

			if (not) {

				if (list[a] != value) {

					total++;

				}

			}else {

				if (list[a] == value) {

					total++;

				}

			}

		}

		return total;

	},

	or: function(list2){

		var list = this;

		if (Exists(list)) {

			return list;

		}

		return list2;

	},

	part: function(start, end){

		var list = this;

		// just get the part we need

		return list.slice(start, end + 1);

	},

	swap: function(slot1, slot2){

		var list = this;

		var temp = list[slot2];

		list[slot2] = list[slot1];

		list[slot1] = temp;

	},

	add: function(item){

		var list = this;

		list.push(item);

		return list.length - 1;

	},

	addToStart: function(item){

		var list = this;

		list.unshift(item);

		return 0;

	},

	/** return false if item exists, true if item does not */

	addOnce: function(value){

		var list = this;

		// return false if item exists

		if (list.indexOf(value) > -1) {

			return false;

		}

		// add if not found

		list.push(value);

		return true;

	},

	addArray: function(toAdd, addAtSlot = -1, modifyMain = true){

		var list = this;

			if (!modifyMain) {

				list = list.concat(); /// shallow clone

			}

			// set length first so allocates memory (maybe?)

			var origLen = list.length;

			if (addAtSlot === -1){

				list.length += toAdd.length;

			}

			// set all slots

			var next = addAtSlot === -1 ? origLen : addAtSlot;

			for (var a = 0, al = toAdd.length;a<al;a++, next++){

				list[next] = toAdd[a];

			}

		}

		return list;

	},

	/** adds the given value many times */

	addManyTimes: function(val, times){

		var list = this;

		if (times <= 0) {

			return list;

		}

		var n = list.length;

		for (var t = 0;t<times;t++){

			list[n++] = val;

		}

		return list;

	},

	addRange: function(toAdd, startSlot, endSlot){

		var list = this;

		// exit if no work

		if (endSlot < startSlot) {

			return;

		}

		// per wanted slot of the `add` array

		startSlot = startSlot.limitToArray(toAdd);

		endSlot = endSlot.limitToArray(toAdd);

		for (var s = startSlot;s <= endSlot;s++){

			// add into `main` array

			list.push(toAdd[s]);

		}

	},

	/** returns final index of added item, or index of already existing item */

	findOrAdd: function(value){

		var list = this;

		// return index of item if exists

		var i = list.indexOf(value);

		if (i > -1) {

			return i;

		}

		// add if not found

		i = list.length;

		list[i] = value;

		return i;

	},

	insertOne: function(item, slot){

		var list = this;

		// adds one slot at the given point

		// modifies the main array

		list.splice(slot, 0, item);

	},

	/** if slot = -1 or outside the array, the item is added to the END of the array.

	 * Otherwise the item is added at the given slot. */

	insertOneOrAdd: function(item, slot){

		var list = this;

		// adds one slot at the given point

		// modifies the main array

		if (slot < 0 || slot >= list.length) {

			list.push(item);

			return list.length - 1;

		}

		list.splice(slot, 0, item);

		return slot;

	},

	insertArray: function(newItems, slot, returnNew = true){

		var list = this;

		// adds many slots at the given point

		// returns a new array

		if(returnNew){

			return list.slice(0, slot).concat(newItems).concat(list.slice(slot));

		}

		// adds many slots at the given point

		// modifies the main array

		for (var a = 0, al = newItems.length;a<al;a++){

			list.splice(slot++, 0, newItems[a]);

		}

		return list;

	},

	insertArrayAfter: function(newItems, after){

		var list = this;

		if (list.isLast(after)) {

			list.addArray(newItems);

		} else {

			var i = list.indexOf(after);

			list.insertArray(i + 1, newItems);

		}

	},

	removeAndInsert: function(from, to){

		var list = this;

		// ensure slots within array

		var al = list.length;

		from = from.limitTo(0, al - 1);

		to = to.limitTo(0, al - 1);

		if (to < from) {

			var i1 = to;

			var i2 = from;

		}else {

			i1 = from;

			i2 = to;

		}

		// fill unaffected header

		var result = [];

		if(i1 > 0){

			for (var a = 0;a<i1;a++){

				result[a] = list[a];

			}

		}

		// fill "to"

		result[to] = list[from];

		// fill between from and to

		if(to < from){

			for (a = to + 1; a <= from; a++) {

				result[a] = list[a - 1];

			}

		}else {

			for (a = from; a < to; a++) {

				result[a] = list[a + 1];

			}

		}

		// fill unaffected footer

			result[a] = list[a];

		}

		return result;

	},

	/** replace a range of items with a given array */

	replaceRange: function(replaceStartSlot, replaceEndSlot, newItems, returnNew = true){

		var list = this;

		// simply remove a single item

		if (replaceStartSlot == replaceEndSlot && newItems.length === 0) {

			if (returnNew) {

				list = list.concat();

			}

			list.splice(replaceStartSlot, 1);

			return list;

		// simply replace a single item

		}else if (replaceStartSlot == replaceEndSlot && newItems.length === 1) {

			if (returnNew) {

				list = list.concat();

			}

			list[replaceStartSlot] = newItems[0];

			return list;

		}

		// alt method if returning a new array

		if(returnNew){

			return list.slice(0, replaceStartSlot).concat(newItems).concat(list.slice(replaceEndSlot + 1));

		}

		// remove many

		list.splice(replaceStartSlot, (replaceEndSlot - replaceStartSlot) + 1);

		// insert many

		var slot = replaceStartSlot;

		for (var a = 0, al = newItems.length;a<al;a++){

			list.splice(slot++, 0, newItems[a]);

		}

		return list;

	},

	replace: function(find, replace, stringReplace = false){

		var list = this;

		for (var i = 0, il = list.length;i<il;i++){

			if (stringReplace){

				// replace substring within string items

				var str = list[i];

				if (str && str.constructor === String) {

					list[i] = str.replaceAll(find, replace);

				}

			}else{

				// replace entire items

				if (list[i] == find) {

					list[i] = replace;

				}

			}

		}

	},

	replaceOnce: function(find, replace){

		var list = this;

		for (var i = 0, il = list.length;i<il;i++){

			if (list[i] == find) {

				list[i] = replace;

				return;

			}

		}

	},

	replaceMany: function(findArray, replaceArray){

		var list = this;

		if (findArray.length != replaceArray.length){

			return;

		}

		for (var i = 0, il = list.length;i<il;i++){

			for (var f = 0, fl = findArray.length;f<fl;f++){

				var find = findArray[f];

				if (list[i] == find) {

					list[i] = replaceArray[f];

					break;

				}

			}

		}

	},

	remove: function(value, stringReplace = false){

		var list = this;

		for (var i = 0, il = list.length;i<il;i++){

			if (stringReplace){

				// remove substring within string items

				var str = list[i];

				if (str && str.constructor === String) {

					list[i] = str.removeAll(value);

				}

			}else{

				// remove entire items

				if (list[i] == value) {

					list.splice(i, 1);

					il--;

				}

			}

		}

	},

	removeOnce: function(val){

		var list = this;

		var i = list.indexOf(val);

		if (i > -1) {

			list.splice(i, 1);

		}

		return i;

	},

	removeFirst: function(returnNew = false){

		var list = this;

		// return new

		if (returnNew) {

			return list.slice(1);

		}

		// modify existing

		if (list.length > 0) {

			list.splice(0, 1);

		}

		return list;

	},

	removeFirstX: function(count, returnNew = false){

		var list = this;

		// if fewer items than wanted, clear entire array

		if (list.length < count) {

			if (returnNew) {

				return [];

			}

			list.length = 0;

			return list;

		}

		// delete X items from start

		// return new

		if (returnNew) {

			return list.slice(count);

		}

		// modify existing

		list.splice(0, count);

		return list;

	},

	removeLast: function(returnNew = false){

		var list = this;

		// return new

		if (returnNew) {

			return list.slice(0, list.length - 1);

		}

		// modify existing

		if (list.length > 0) {

			list.splice( - 1, 1);

		}

		return list;

	},

	removeLastX: function(count, returnNew = false){

		var list = this;

		// if fewer items than wanted, clear entire array

		if (list.length < count) {

			if (returnNew) {

				return [];

			}

			list.length = 0;

			return list;

		}

		// delete X items from end

		// return new

		if (returnNew) {

			return list.slice(0, list.length - count);

		}

		// modify existing

		list.splice( -count, count);

		return list;

	},

	removeEdges: function(fromLeftEdge, fromRightEdge){

		var list = this;

		if ((list.length - fromLeftEdge - fromRightEdge) <= 0) {

			return [];

		}

		return list.slice(fromLeftEdge, list.length - fromRightEdge);

	},

	splitAt: function(slot, includeSlot = false, includeInFirst = false){

		var list = this;

		if (includeSlot) {

			if (includeInFirst) {

				return [list.slice(0, slot + 1), list.slice(slot + 1)];

				return [list.slice(0, slot), list.slice(slot)];

			}

		}

		return [list.slice(0, slot), list.slice(slot+1)];

	},

	splitAtEvery: function(val){

		var list = this;

		var splits = [];

		var lastSlot = 0;

		for (var a = 0, al = list.length;a<al;a++){

			if (list[a] == val && a > lastSlot) {

				splits.push(list.slice(lastSlot, a));

				lastSlot = a + 1;

			}

		}

		return splits;

	},

	moveToTop: function(slot, returnNew = false){

		var list = this;

			// ALWAYS RETURNS NEW ARRAY

			// exit quickly if slot not in array

			var al = list.length;

			if (slot < 0 || slot >= al) {

				return list.concat();

			}

			// create new array with slot on top

			var newArr = [list[slot]];

			var n = 1;

			// add all other slots

			for (var a = 0;a<al;a++){

				if (a != slot) {

					newArr[n++] = list[a];

				}

			}

			return newArr;

		}

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array

		if (slot < 0 || slot >= al) {

		}

		// delete and re-add slot

		var val = list[slot];

		list.splice(slot, 1);

	},

	moveToBottom: function(slot, returnNew = false){

		var list = this;

			// ALWAYS RETURNS NEW ARRAY

			// exit quickly if slot not in array

			var al = list.length;

			if (slot < 0 || slot >= al) {

				return list.concat();

			}

			// create new array with slot on top

			var newArr = [];

			var n = 0;

			// add all other slots

			for (var a = 0;a<al;a++){

				if (a != slot) {

					newArr[n++] = list[a];

				}

			}

			// add slot to bottom

			return newArr;

		}

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array

		if (slot < 0 || slot >= al) {

		}

		// delete and re-add slot

		var val = list[slot];

		list.splice(slot, 1);

	},

	moveUp: function(item){

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already on top

		var slot = list.indexOf(item);

		if (slot <= 0) {

			return false;

		}

		// move one up

		list.swap(slot, slot - 1);

		return true;

	},

	moveDown: function(item){

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already at bottom

		var al = list.length;

		var slot = list.indexOf(item);

		if (slot < 0 || slot >= (al - 1)) {

			return false;

		}

		// move one down

		list.swap(slot, slot + 1);

		return true;

	},

	moveSlotUp: function(slot){

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already on top

		var al = list.length;

		if (slot <= 0 || slot >= al) {

			return false;

		}

		// move one up

		list.swap(slot, slot - 1);

		return true;

	},

	moveSlotDown: function(slot){

		var list = this;

		// MODIFIES ARRAY IN PLACE

		// exit quickly if slot not in array, or already at bottom

		var al = list.length;

		if (slot < 0 || slot >= (al - 1)) {

			return false;

		}

		// move one down

		list.swap(slot, slot + 1);

		return true;

	},

	/** Move an item from the given list, to the start/end of the target list */

	moveToArray: function(item, toList, evenIfExists = false, addToEnd = true){

		var list = this;

		// remove from source list

		RemoveOne(list, item);

		// add to target list

		if (evenIfExists || toList.indexOf(item) === -1) {

			if (addToEnd) {

				toList.push(item);

			}else{

				toList.unshift(item);

			}

			return true;

		}

		return false;

	},

	contains: function(value){

		var list = this;

		if (list.length === 1) {

			return list[0] == value;

		}

		return list.indexOf(value) > -1;

	},

	containsAny: function(values){

		var list = this;

		return IndexOfAny(list, values) > -1;

	},

	containsAll: function(values){

		var list = this;

		// exit if either null

			return false;

		}

		// check if all found

		for (var f = 0, fl = values.length;f<fl;f++){

			if (list.indexOf(values[f]) === -1) {

				return false;

			}

		}

		return true;

	},

	indexOfArray: function(containsArr){

		var list = this;

		// returns index of containing list in main array

		if (list.length < containsArr.length) {

			return -1;

		}

		var cl = containsArr.length;

		for (var a = 0, al = list.length - (cl - 1);a<al;a++){

			var allMatch = true;

			for (var c = 0;c<cl;c++){

				if (list[a+c] != containsArr[c]) {

					allMatch = false;

					break;

				}

			}

			if (allMatch) {

				return a;

			}

		}

		return -1;

	},

	/** Returns the nearest existing slot value in the array. Returns `ifNoSlots` if the array is empty. */

	within: function(slot, ifNoSlots = null){

		var list = this;

		// return null if array empty

		var len = list.length;

		if (len === 0) {

			return ifNoSlots;

		}

		// return first slot if index negative

		if (slot < 0) {

			return list[0];

		}

		// return last slot if index more than last slot

		if (slot >= len) {

			return list[len - 1];

		}

		// return given slot if within array

		return list[slot];

	},

	first: function(list){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return null;

		}

		return list[0];

	},

	firstExisting: function(slots, blankVal = null){

		var list = this;

		for (var s = 0, sl = slots.length;s<sl;s++){

			var val;

			if ((val = list[slots[s]]) != blankVal) {

				return val;

			}

		}

		return null;

	},

	last: function(list){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return null;

		}

		return list[len-1];

	},

	lastX: function(count){

		var list = this;

		var s = (0).max(list.length - count);

		return list.slice(s, list.length);

	},

	setFirst: function(value){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return;

		}

		list[0] = value;

	},

	setLast: function(value){

		var list = this;

		var len = list.length;

		if (len === 0) {

			return;

		}

		list[len-1] = value;

	},

	random: function(list){

		var list = this;

		// return null if array empty

		if (list.length === 0) {

			return null;

		}

		// return random slot within array

		return list[parseInt(Math.random() * 1000000) % list.length];

	},

	pick: function(IDs, sameSlots = false, fastAndUnsafe = false, out = null, evenIfNull = false){

		var list = this;

			out = [];

		}

		if (IDs){

			if (fastAndUnsafe) {

				for (var i = 0, il = IDs.length;i<il;i++){

					var id = IDs[i];

					var val = list[id];

					if (sameSlots) {

						out[id] = val;

					}else{

						out.push(val);

					}

				}

			}else{

					id = IDs[i];

					if (id > -1){

						val = list[id];

							if (sameSlots) {

								out[id] = val;

							}else{

								out.push(val);

							}

						}

					}

				}

			}

		}

		return out;

	},

	/** Get the data of `list`, by searching `indexID` in `indexArr`, or return `defaultVal` if not found */

	getByMatchingArray: function(indexArr, indexID, defaultVal = null){

		var list = this;

		var slot = indexArr.indexOf(indexID);

		return slot === -1 ? defaultVal : list[slot];

	},

	/** Set the data of `list`, by searching `indexID` in `indexArr` */

	setByMatchingArray: function(indexArr, indexID, data){

		var list = this;

		var slot = indexArr.indexOf(indexID);

		if (slot === -1) {

			return false;

		}

		list[slot] = data;

		return true;

	},

	page: function(page, pageLength, invisibleRows = null){

		var list = this;

		// ensure page no. in limits

		var lastPage = Math.ceil(list.length / pageLength);

		page = page.limitTo(0, lastPage - 1);

		// get first/last row in page

		var pageStart = page*pageLength;/// 0-based - first row in page

		var pageEnd = (pageStart + pageLength) - 1;/// 0-based - last row in page

		// get on-page rows

		var visibleRows = list.getRange(pageStart, pageLength);

		// get off-page rows

		if (invisibleRows) {

			invisibleRows.addRange(list, 0, pageStart - 1);

			invisibleRows.addRange(list, pageEnd + 1, list.length - 1);

		}

		return visibleRows;

	},

	trim: function(returnNew = false, trimVal = null){

		var list = this;

		var first = IndexOf(list, trimVal, true);

		if (first === -1) {

			if (returnNew) {

				return [];

				list.length = 0;

			}

		}else{

			var last = list.lastIndexOf(trimVal, true);

			if (returnNew) {

				return GetManySE(list, first, last);

					DeleteManySE(list, 0, first-1);

				}

				if (last != -1){

					list.length = last - first + 1;